home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / p4 / p4-1_2a.lha / p4-1.2a / lib_f / p4_fort.c < prev    next >
C/C++ Source or Header  |  1992-10-19  |  5KB  |  360 lines
  1. #include "p4.h"
  2. #include "p4_sys.h"
  3. #include "p4_fort.h"
  4.  
  5. VOID p4sendr_(type,dest,msg,len,rc)
  6. int *type, *dest, *len;
  7. char *msg;
  8. int *rc;
  9. {
  10.     p4_dprintfl(20,"in p4sendr_, type=%d, dest=%d, len=%d\n",
  11.         *type, *dest, *len);
  12.     *rc = p4_sendr(*type, *dest, msg, *len);
  13. }
  14.  
  15. VOID p4sendrx_(type,dest,msg,len,data_type,rc)
  16. int *type, *dest, *data_type, *len;
  17. char *msg;
  18. int *rc;
  19. {
  20.     p4_dprintfl(20,"in p4sendrx_, type=%d, dest=%d, dtype=%d len=%d\n",
  21.         *type, *dest, *data_type, *len);
  22.     *rc = p4_sendrx(*type, *dest, msg, *len, *data_type);
  23. }
  24.  
  25. VOID p4send_(type,dest,msg,len,rc)
  26. int *type, *dest, *len;
  27. char *msg;
  28. int *rc;
  29. {
  30.     p4_dprintfl(20,"in p4send_, type=%d, dest=%d, len=%d\n",
  31.         *type, *dest, *len);
  32.     *rc = p4_send(*type, *dest, msg, *len);
  33. }
  34.  
  35. VOID p4sendx_(type,dest,msg,len,data_type,rc)
  36. int *type, *dest, *data_type, *len;
  37. char *msg;
  38. int *rc;
  39. {
  40.     p4_dprintfl(20,"in p4sendx_, type=%d, dest=%d, dtype=%d len=%d\n",
  41.         *type, *dest, *data_type, *len);
  42.     *rc = p4_sendx(*type, *dest, msg, *len, *data_type);
  43. }
  44.  
  45. VOID p4recv_(type,from,buf,buflen,msglen,rc)
  46. int *type, *from;
  47. char *buf;
  48. int *buflen, *msglen, *rc;
  49. {
  50.     char *temp_buf;
  51.     int temp_len;
  52.  
  53.     p4_dprintfl(20, "p4_recv_: receiving, type=%d, from=%d, buflen=%d\n",
  54.         *type, *from, *buflen);
  55.     temp_buf = NULL;
  56.     *rc = p4_recv(type,from,&temp_buf,&temp_len);
  57.     if (*rc < 0)
  58.     p4_dprintf("p4recv_: p4_recv failed\n");
  59.     else
  60.     {
  61.     if (temp_len > *buflen)
  62.     {
  63.         *msglen = *buflen;
  64.         *rc = 1;
  65.     }
  66.     else
  67.         *msglen = temp_len;
  68.     bcopy(temp_buf,buf,*msglen);
  69.     p4_msg_free(temp_buf);
  70.     }
  71.     p4_dprintfl(20, "p4_recv_: received, len=%d\n",*msglen);
  72. }
  73.   
  74. VOID p4brdcst_(type,data,len,rc)
  75. int *type, *len;
  76. char *data;
  77. int *rc;
  78. {
  79.     *rc = p4_broadcast(*type, data, *len);
  80. }
  81.  
  82. VOID p4brdcstx_(type,data,len,data_type,rc)
  83. int *type, *data_type, *len;
  84. char *data;
  85. int *rc;
  86. {
  87.     *rc = p4_broadcastx(*type, data, *len, *data_type);
  88. }
  89.  
  90. VOID p4probe_(type,from,rc)
  91. int *type, *from, *rc;
  92. {
  93.     *rc = (int) p4_messages_available(type, from);
  94. }
  95.  
  96. int p4myclid_()
  97. {
  98.     return p4_get_my_cluster_id();
  99. }
  100.  
  101. int p4nclids_()
  102. {
  103.     return p4_num_cluster_ids();
  104. }
  105.  
  106. VOID p4globarr_(type)
  107. int *type;
  108. {
  109.     (VOID) p4_global_barrier(*type);
  110. }
  111.  
  112. VOID p4getclmasts_(numids,ids)
  113. int *numids,*ids;
  114. {
  115.     (VOID) p4_get_cluster_masters(numids,ids);
  116. }
  117.  
  118. VOID p4getclids_(start,end)
  119. int *start,*end;
  120. {
  121.     (VOID) p4_get_cluster_ids(start,end);
  122. }
  123.  
  124. int p4myid_()
  125. {
  126.     return p4_get_my_id();
  127. }
  128.  
  129. int p4clock_()
  130. {
  131.     return p4_clock();
  132. }
  133.  
  134. int p4ustimer_()
  135. {
  136.     return p4_ustimer();
  137. }
  138.  
  139. int p4ntotids_()
  140. {
  141.     return p4_num_total_ids();
  142. }
  143.  
  144. int p4nslaves_()
  145. {
  146.     return p4_num_total_slaves();
  147. }
  148.  
  149. VOID p4error_(str,val)
  150. char *str;
  151. int *val;
  152. {
  153.     (VOID) p4_error(str,*val);
  154. }
  155.  
  156. VOID p4avlbufs_()
  157. {
  158.     p4_print_avail_buffs();
  159. }
  160.  
  161. VOID p4setavlbuf_(idx,size)
  162. int *idx, *size;
  163. {
  164.     p4_set_avail_buff((*idx)-1,*size);
  165. }
  166.  
  167. VOID p4softerrs_(new,old)
  168. int new,*old;
  169. {
  170.     *old = (int) p4_soft_errors(new);
  171. }
  172.  
  173. VOID p4version_()
  174. {
  175.     printf("p4version %s\n",p4_version());
  176. }
  177.  
  178. VOID p4globop_(type, x, nelem, size, op, data_type, rc)
  179. int *type;
  180. char *x;
  181. int *nelem;
  182. int *size;
  183. int *data_type;
  184. int *rc;
  185. VOID (*op)();
  186. {
  187. int *opind;
  188.  
  189.     *rc = p4_global_op(*type, x, *nelem, *size, op, *data_type);
  190. }
  191.  
  192. VOID p4dblsumop_(a,b,n)
  193. char *a,*b;
  194. int n;
  195. {
  196.     p4_dbl_sum_op(a,b,n);
  197. }
  198.  
  199. VOID p4dblmultop_(a,b,n)
  200. char *a,*b;
  201. int n;
  202. {
  203.     p4_dbl_mult_op(a,b,n);
  204. }
  205.  
  206. VOID p4dblmaxop_(a,b,n)
  207. char *a,*b;
  208. int n;
  209. {
  210.     p4_dbl_max_op(a,b,n);
  211. }
  212.  
  213. VOID p4dblminop_(a,b,n)
  214. char *a,*b;
  215. int n;
  216. {
  217.     p4_dbl_min_op(a,b,n);
  218. }
  219.  
  220. VOID p4dblabsmaxop_(a,b,n)
  221. char *a,*b;
  222. int n;
  223. {
  224.     p4_dbl_absmax_op(a,b,n);
  225. }
  226.  
  227. VOID p4dblabsminop_(a,b,n)
  228. char *a,*b;
  229. int n;
  230. {
  231.     p4_dbl_absmin_op(a,b,n);
  232. }
  233.  
  234. VOID p4fltsumop_(a,b,n)
  235. char *a,*b;
  236. int n;
  237. {
  238.     p4_flt_sum_op(a,b,n);
  239. }
  240.  
  241. VOID p4fltmultop_(a,b,n)
  242. char *a,*b;
  243. int n;
  244. {
  245.     p4_flt_mult_op(a,b,n);
  246. }
  247.  
  248. VOID p4fltmaxop_(a,b,n)
  249. char *a,*b;
  250. int n;
  251. {
  252.     p4_flt_max_op(a,b,n);
  253. }
  254.  
  255. VOID p4fltminop_(a,b,n)
  256. char *a,*b;
  257. int n;
  258. {
  259.     p4_flt_min_op(a,b,n);
  260. }
  261.  
  262. VOID p4fltabsmaxop_(a,b,n)
  263. char *a,*b;
  264. int n;
  265. {
  266.     p4_flt_absmax_op(a,b,n);
  267. }
  268.  
  269. VOID p4fltabsminop_(a,b,n)
  270. char *a,*b;
  271. int n;
  272. {
  273.     p4_flt_absmin_op(a,b,n);
  274. }
  275.  
  276. VOID p4intsumop_(a,b,n)
  277. char *a,*b;
  278. int n;
  279. {
  280.     p4_int_sum_op(a,b,n);
  281. }
  282.  
  283. VOID p4intmultop_(a,b,n)
  284. char *a,*b;
  285. int n;
  286. {
  287.     p4_int_mult_op(a,b,n);
  288. }
  289.  
  290. VOID p4intmaxop_(a,b,n)
  291. char *a,*b;
  292. int n;
  293. {
  294.     p4_int_max_op(a,b,n);
  295. }
  296.  
  297. VOID p4intminop_(a,b,n)
  298. char *a,*b;
  299. int n;
  300. {
  301.     p4_int_min_op(a,b,n);
  302. }
  303.  
  304. VOID p4intabsmaxop_(a,b,n)
  305. char *a,*b;
  306. int n;
  307. {
  308.     p4_int_absmax_op(a,b,n);
  309. }
  310.  
  311. VOID p4intabsminop_(a,b,n)
  312. char *a,*b;
  313. int n;
  314. {
  315.     p4_int_absmin_op(a,b,n);
  316. }
  317.  
  318. VOID slave()
  319. {
  320.     fslave_();
  321. }
  322.  
  323. VOID p4flush_()
  324. {
  325.     printf("\n");
  326.     fflush(stdout);
  327. }
  328.  
  329. VOID slstart_()
  330. {
  331.     int argc;
  332.     char *argv[10];
  333.     char *q;
  334.  
  335.     p4_dprintfl(30, "enter fortran slstart \n");
  336.     for(argc=0; argc<4; argc++)
  337.     {
  338.     q = (char *)malloc(200);
  339.     /* args Fortran subroutine */
  340.     args_(&argc,q);
  341.     argv[argc] = q;
  342.     q = (char *)index(argv[argc],' ');
  343.     *q = '\0';
  344.     p4_dprintfl(30,"\n fortran slstart argv[%d] = :%s:\n",
  345.             argc,argv[argc]);
  346.     }
  347.     p4_dprintfl(30, "slstart len of argv[1] = %d\n",strlen(argv[1]));
  348.     /*******
  349.     _F_init(argc,argv,0,0);
  350.     *******/
  351.  
  352.     p4_initenv(&argc, argv);
  353.     slave();
  354.     p4_wait_for_end();
  355.  
  356.     p4_dprintfl(30, "exit fortran slstart\n");
  357. }
  358.  
  359.  
  360.